package org.xiaov.core.string;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xiaov.core.collection.ListHelper;

import java.util.Arrays;
import java.util.List;
import java.util.Random;

/**
 * @description: 操作字符串的帮助类
 * @author: xiaovcloud
 * @date: 2021/1/17 14:50
 */
public class StringHelper {
    private static final Logger log = LoggerFactory.getLogger(StringHelper.class);
    private static final char SEPARATOR = '_';

    public static boolean isEmpty(String str) {
        return str == null || "".equals(str);
    }

    public static boolean isEmpty(String... params) {
        boolean flag = true;
        for (String obj : params) {
            flag = (obj == null || "".equals(obj));
            if (!flag) {
                break;
            }
        }
        return flag;
    }

    public static boolean isNotEmpty(String... params) {
        return !isEmpty(params);
    }


    /**
     * 遍历string数组
     *
     * @param array
     * @return
     */
    public static String printArray(String[] array) {
        return Arrays.asList(array).toString();
    }


    /**
     * 将字符串首字母转大写.
     *
     * @param str 需要处理的字符串
     */
    public static String upperFirstChar(String str) {
        if (isEmpty(str)) {
            return "";
        }
        char[] cs = str.toCharArray();
        char start = 'a';
        char end = 'z';
        if ((cs[0] >= start) && (cs[0] <= end)) {
            cs[0] -= (char) 0x20;
        }
        return String.valueOf(cs);
    }

    /**
     * 将字符串首字母转小写.
     *
     * @param str
     * @return
     */
    public static String lowerFirstChar(String str) {
        if (isEmpty(str)) {
            return "";
        }
        char[] cs = str.toCharArray();
        char start = 'A';
        char end = 'Z';
        if ((cs[0] >= start) && (cs[0] <= end)) {
            cs[0] += (char) 0x20;
        }
        return String.valueOf(cs);
    }

    /**
     * 将{@Code reg}分割的字符串组合成集合
     *
     * @param separator
     * @param str
     * @return
     */
    public static List<String> toList(String str, String separator) {
        if ("".equals(str)) {
            return ListHelper.newArrayList();
        }
        return Arrays.asList(str.split(separator));
    }

    /**
     * 将逗号(,)分割的字符串组合成集合
     *
     * @param str
     * @return
     */
    public static List<String> toList(String str) {
        return toList(str, ",");
    }

    /**
     * 比较两个字符串（大小写敏感）。
     *
     * <pre>
     * equals(null, null)   = true
     * equals(null, &quot;abc&quot;)  = false
     * equals(&quot;abc&quot;, null)  = false
     * equals(&quot;abc&quot;, &quot;abc&quot;) = true
     * equals(&quot;abc&quot;, &quot;ABC&quot;) = false
     * </pre>
     *
     * @param str1 要比较的字符串1
     * @param str2 要比较的字符串2
     *
     * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
     */
    public static boolean equals(CharSequence str1, CharSequence str2) {
        return equals(str1, str2, false);
    }

    /**
     * 比较两个字符串（大小写不敏感）。
     *
     * <pre>
     * equalsIgnoreCase(null, null)   = true
     * equalsIgnoreCase(null, &quot;abc&quot;)  = false
     * equalsIgnoreCase(&quot;abc&quot;, null)  = false
     * equalsIgnoreCase(&quot;abc&quot;, &quot;abc&quot;) = true
     * equalsIgnoreCase(&quot;abc&quot;, &quot;ABC&quot;) = true
     * </pre>
     *
     * @param str1 要比较的字符串1
     * @param str2 要比较的字符串2
     *
     * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
     */
    public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
        return equals(str1, str2, true);
    }

    /**
     * 比较两个字符串是否相等。
     *
     * @param str1 要比较的字符串1
     * @param str2 要比较的字符串2
     * @param ignoreCase 是否忽略大小写
     * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
     * @since 3.2.0
     */
    public static boolean equals(CharSequence str1, CharSequence str2, boolean ignoreCase) {
        if (null == str1) {
            // 只有两个都为null才判断相等
            return str2 == null;
        }
        if (null == str2) {
            // 字符串2空，字符串1非空，直接false
            return false;
        }

        if (ignoreCase) {
            return str1.toString().equalsIgnoreCase(str2.toString());
        } else {
            return str1.equals(str2);
        }
    }
}
